home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Audio / Patchmix / XWindowsSource / unit_gen.c < prev    next >
C/C++ Source or Header  |  1992-03-28  |  12KB  |  411 lines
  1. static char rcsid[] = "$Header: unit_gen.c,v 1.7 91/02/13 09:46:41 mara Exp $";
  2.  
  3. /* unit_gen.c
  4.  *
  5.  *  Written by Mara Helmuth
  6.  *
  7.  *  Description: unit_generator class for cmix X graphical interface
  8.  * 
  9.  *  $Log:    unit_gen.c,v $
  10.  * Revision 1.7  91/02/13  09:46:41  mara
  11.  * panel fixes
  12.  * 
  13.  * Revision 1.6  90/10/11  10:32:00  mara
  14.  * am fix
  15.  * 
  16.  * Revision 1.5  90/09/08  12:49:54  mara
  17.  * side panel for input amps
  18.  * 
  19.  * Revision 1.4  90/09/07  20:50:46  mara
  20.  * fm
  21.  * 
  22.  * Revision 1.3  90/09/05  22:10:53  mara
  23.  * many fixes, +,-,*,/ ugens added
  24.  * 
  25.  * Revision 1.2  90/09/02  18:19:25  mara
  26.  * NeXT fixes
  27.  * 
  28.  * Revision 1.1  90/08/27  17:09:50  mara
  29.  * Initial revision
  30.  * 
  31. */
  32.  
  33. #include "plus.h"
  34.  
  35. unit_generator::unit_generator()
  36. {
  37.     sprintf(file,"Newinst/%s.c",inst.name);
  38.     fp = fopen(file, "a");
  39.     if(!fp)
  40.         perror(file);
  41.     beg_int = inst.num_ints;
  42.     beg_float = inst.num_sfloats;
  43.     beg_float_ptr = inst.num_float_ptrs;
  44. }
  45.  
  46. void unit_generator::write_oscil(int p, int l, int r)
  47. {
  48. // create instrument variables
  49.  
  50.     sprintf(inst.ints[inst.num_ints++],"len%d",p);
  51.     sprintf(inst.ints[inst.num_ints++],"wave%d",p);
  52.  
  53.     sprintf(inst.sfloats[inst.num_sfloats++],"ug%d",p);     // 0
  54.     sprintf(inst.sfloats[inst.num_sfloats++],"amp%d",p);    // 1
  55.     sprintf(inst.sfloats[inst.num_sfloats++],"si%d",p);     // 2
  56.     sprintf(inst.sfloats[inst.num_sfloats++],"phase%d",p);     // 3
  57.  
  58.     sprintf(inst.float_ptrs[inst.num_float_ptrs++],"f%d",p);
  59.  
  60.     strcpy(oscil_type,"oscili");
  61.     sprintf(amp_var,"%s",inst.sfloats[beg_float+1]);
  62.     sprintf(si_var,"%s",inst.sfloats[beg_float + 2]);
  63.  
  64. // create instrument commands
  65.     sprintf(cmd,"%s = 1;\n",inst.ints[beg_int+1]); // wave
  66.     inst.cmd_list.append(cmd);
  67.     if(l > 0) {  // there is an input ugen to amplitude - ring mod
  68.         sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float+1],
  69.             atof(ugen[p].oscil->amp->value));
  70.             // amp? = ?;
  71.         inst.loop_list.append(cmd);
  72.  
  73.         sprintf(amp_var,"ampam%d",p);
  74.         strcpy(inst.sfloats[inst.num_sfloats++],amp_var); 
  75.         sprintf(cmd,"%s = %s * ug%d;\n",amp_var,  
  76.             inst.sfloats[beg_float+1],l);
  77.         inst.loop_list.append(cmd);
  78.     }
  79.     else if(l < 0) // amp is a pfield for this oscil
  80.         ;
  81.     else {         // amp is preset or default
  82.         sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float+1],
  83.             atof(ugen[p].oscil->amp->value));
  84.         inst.loop_list.append(cmd);
  85.     }
  86.     if(r < 0) { // oscil.freq is not set--make a pfield
  87.         inst.pfield++;
  88.         sprintf(cmd,"%s = p[%d]*fsize(1)/SR;\n",
  89.             inst.sfloats[beg_float+2], inst.pfield);
  90.         inst.p[inst.pfield] = 260;
  91.     }
  92.     else if(r == 0) {    // oscil.freq is preset 
  93.         sprintf(cmd,"%s = %.2f*fsize(1)/SR;\n",inst.sfloats[beg_float+2], atof(ugen[p].oscil->freq->value));
  94.     }
  95.     else  {
  96.         printf("fm selected\n");
  97.         strcpy(oscil_type,"oscilni");
  98.         sprintf(si_var,"sifm%d",p);
  99.         strcpy(inst.sfloats[inst.num_sfloats++],si_var); 
  100.         
  101.         sprintf(cmd,"%s = si%d + ug%d * len%d/SR;\n", si_var,p,r,p);
  102.         inst.loop_list.append(cmd);
  103.         sprintf(cmd,"si%d = %.2f*fsize(1)/SR;\n",p, 
  104.             atof(ugen[p].oscil->freq->value),p);
  105.     }
  106.     inst.cmd_list.append(cmd);
  107.     sprintf(cmd,"%s = 0.;\n",inst.sfloats[beg_float+3]);
  108.     inst.cmd_list.append(cmd);
  109.     sprintf(cmd,"%s = fsize(%s);\n",inst.ints[beg_int],inst.ints[beg_int+1]);
  110.     inst.cmd_list.append(cmd);
  111.     sprintf(cmd,"%s = (float *)floc(%s);\n",inst.float_ptrs[beg_float_ptr],inst.ints[beg_int+1]);
  112.     inst.cmd_list.append(cmd);
  113.  
  114.     sprintf(cmd, "%s = %s(%s,%s,%s,%s,&%s);\n",inst.sfloats[beg_float], \
  115.         oscil_type,amp_var,si_var,\
  116.         inst.float_ptrs[beg_float_ptr],inst.ints[beg_int], \
  117.         inst.sfloats[beg_float+3]);
  118.     inst.loop_list.append(cmd);
  119.  
  120. // declare instrument variables
  121.  
  122.  
  123.     declare(beg_int, beg_float, beg_float_ptr);
  124. }
  125.  
  126. void unit_generator::write_evp(int p, int l, int r)
  127. {
  128. // create instrument variables
  129.  
  130.     sprintf(inst.ints[inst.num_ints++],"nfrise%d",p);
  131.  
  132.     sprintf(inst.sfloats[inst.num_sfloats++],"ug%d",p);     // 0
  133.     sprintf(inst.sfloats[inst.num_sfloats++],"amp%d",p);     // 1
  134.     sprintf(inst.sfloats[inst.num_sfloats++],"dur%d",p);     // 2
  135.     sprintf(inst.sfloats[inst.num_sfloats++],"rise%d",p);    // 3
  136.     sprintf(inst.sfloats[inst.num_sfloats++],"decay%d",p);     // 4
  137.     sprintf(inst.sfloats[inst.num_sfloats++],"q%d",p);    // 5
  138.         // q[9] should be declared, q used in evset
  139.  
  140.     sprintf(inst.float_ptrs[inst.num_float_ptrs++],"f1_%d",p);
  141.     sprintf(inst.float_ptrs[inst.num_float_ptrs++],"f2_%d",p);
  142.  
  143. // create instrument commands
  144.     
  145.     sprintf(cmd,"%s = %f;\n",inst.sfloats[beg_float+1],atof(ugen[p].evp->amp->value));    
  146.     inst.cmd_list.append(cmd);
  147.     sprintf(cmd,"%s = %d;\n",inst.ints[beg_int],atoi(ugen[p].evp->nfunc->value)+2);    // function for rise (& decay)
  148.     inst.cmd_list.append(cmd);
  149.     sprintf(cmd,"%s = %f;\n",inst.sfloats[beg_float+3],atof(ugen[p].evp->rise->value));
  150.     inst.cmd_list.append(cmd);
  151.     sprintf(cmd,"%s = %f;\n",inst.sfloats[beg_float+4],atof(ugen[p].evp->decay->value));
  152.     inst.cmd_list.append(cmd);
  153.     sprintf(cmd,"evset(p[1],%s,%s,%s,%s);\n",inst.sfloats[beg_float+3],inst.sfloats[beg_float+4],inst.ints[beg_int],inst.sfloats[beg_float+5]);
  154.     inst.cmd_list.append(cmd);
  155.     sprintf(cmd,"%s = (float *)floc(%s);\n",inst.float_ptrs[beg_float_ptr],inst.ints[beg_int]);
  156.     inst.cmd_list.append(cmd);
  157.     sprintf(cmd,"%s = %s;\n",inst.float_ptrs[beg_float_ptr+1],inst.float_ptrs[beg_float_ptr]);
  158.     inst.cmd_list.append(cmd);
  159.  
  160.     if(l > 0) {  // there is an input ugen to amplitude 
  161. /*
  162.         sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float+1],
  163.             atof(ugen[p].evp->amp->value));
  164.             // amp? = ?;
  165.         inst.loop_list.append(cmd);
  166.  
  167.         sprintf(amp_var,"ampam%d",p);
  168.         sprintf(cmd,"%s = %s * ug%d;\n",inst.sfloats[beg_float],  
  169.             inst.sfloats[beg_float+1],l);
  170.         inst.loop_list.append(cmd);
  171. */
  172.     }
  173.     else if(l < 0) // amp is a pfield for this evp
  174.         ;
  175.     else {         // amp is preset or default
  176.         sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float],
  177.             atof(ugen[p].evp->amp->value));
  178.         inst.loop_list.append(cmd);
  179.     }
  180.     if(r < 0) { 
  181.     }
  182. /*
  183.     else if(r == 0) {    // evp.rise is preset 
  184.         sprintf(cmd,"%s = %.3f;\n",inst.sfloats[beg_float+2], atof(ugen[p].evp->rise->value));
  185.     }
  186. */
  187.     inst.cmd_list.append(cmd);
  188.  
  189.     sprintf(cmd, "%s = evp(i,%s,%s,%s);\n",inst.sfloats[beg_float], \
  190.         inst.float_ptrs[beg_float_ptr], \
  191.         inst.float_ptrs[beg_float_ptr+1], inst.sfloats[beg_float+5]);
  192.     inst.loop_list.append(cmd);
  193.  
  194. // declare instrument variables
  195.  
  196.  
  197.     strcat(inst.sfloats[beg_float+5],"[9]");  // for array declaration 
  198.     declare(beg_int, beg_float, beg_float_ptr);
  199. }
  200.  
  201. void unit_generator::write_buzz(int p, int l, int r)
  202. {
  203.     char buzz_type[20];
  204. // create instrument variables
  205.  
  206.     sprintf(inst.ints[inst.num_ints++],"wave%d",p);
  207.  
  208.     sprintf(inst.sfloats[inst.num_sfloats++],"ug%d",p);     // 0
  209.     sprintf(inst.sfloats[inst.num_sfloats++],"amp%d",p);    // 1
  210.     sprintf(inst.sfloats[inst.num_sfloats++],"si%d",p);     // 2
  211.     sprintf(inst.sfloats[inst.num_sfloats++],"nhar%d",p);     // 3
  212.     sprintf(inst.sfloats[inst.num_sfloats++],"phase%d",p);     // 4
  213.  
  214.     sprintf(inst.float_ptrs[inst.num_float_ptrs++],"f%d",p); //farray
  215.  
  216.     strcpy(buzz_type,"buzz");
  217.     sprintf(amp_var,"%s",inst.sfloats[beg_float+1]);
  218.     sprintf(si_var,"%s",inst.sfloats[beg_float + 2]);
  219.  
  220. // create instrument commands
  221.     sprintf(cmd,"%s = 1;\n",inst.ints[beg_int]); // wave
  222.     inst.cmd_list.append(cmd);
  223.     if(l > 0) {  // there is an input ugen to amplitude 
  224.         sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float+1],
  225.             atof(ugen[p].buzz->amp->value));
  226.             // amp? = ?;
  227.         inst.loop_list.append(cmd);
  228.  
  229.         sprintf(amp_var,"ampam%d",p);
  230.         strcpy(inst.sfloats[inst.num_sfloats++],amp_var); 
  231.         sprintf(cmd,"%s = %s * ug%d;\n",amp_var,  
  232.             inst.sfloats[beg_float+1],l);
  233.         inst.loop_list.append(cmd);
  234.     }
  235.     else if(l < 0) // amp is a pfield for this buzz
  236.         ;
  237.     else {         // amp is preset or default
  238.         sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float+1],
  239.             atof(ugen[p].buzz->amp->value));
  240.         inst.loop_list.append(cmd);
  241.     }
  242.     if(r < 0) { // buzz.freq is not set--make a pfield
  243.         inst.pfield++;
  244.         sprintf(cmd,"%s = p[%d]*fsize(1)/SR;\n",
  245.             inst.sfloats[beg_float+2], inst.pfield);
  246.         inst.p[inst.pfield] = 260;
  247.     }
  248.     else if(r == 0) {    // buzz.freq is preset 
  249.         sprintf(cmd,"%s = %.2f*fsize(1)/SR;\n",inst.sfloats[beg_float+2], atof(ugen[p].buzz->freq->value));
  250.     }
  251.     else  {
  252.         printf("fm selected - doesn't work\n");
  253.     }
  254.     inst.cmd_list.append(cmd);
  255.     sprintf(cmd,"%s = 0.;\n",inst.sfloats[beg_float+4]); // phase
  256.     inst.cmd_list.append(cmd);
  257.     sprintf(cmd,"%s = (float *)floc(%s);\n",inst.float_ptrs[beg_float_ptr],inst.ints[beg_int]);
  258.     inst.cmd_list.append(cmd);
  259.     sprintf(cmd,"%s = %.2f;\n",inst.sfloats[beg_float+3],
  260.             atof(ugen[p].buzz->nhar->value));
  261.     inst.cmd_list.append(cmd);
  262.  
  263.     sprintf(cmd, "%s = %s(%s,%s,%s,%s,&%s);\n",inst.sfloats[beg_float], \
  264.         buzz_type,amp_var,si_var, inst.sfloats[beg_float+3], \
  265.         inst.float_ptrs[beg_float_ptr], inst.sfloats[beg_float+4]);
  266.     inst.loop_list.append(cmd);
  267.  
  268. // declare instrument variables
  269.  
  270.  
  271.     declare(beg_int, beg_float, beg_float_ptr);
  272. }
  273.  
  274. void unit_generator::write_add(int p, int l, int r)
  275. {
  276.     fprintf(fp, "\tfloat ug%d;\n",p);
  277.     declare(beg_int, beg_float, beg_float_ptr);
  278.     float l_fact, r_fact;
  279.     l_fact = atof(ugen[p].side->in0->value);
  280.     r_fact = atof(ugen[p].side->in1->value);
  281.     if(l && r)
  282.         sprintf(cmd, "ug%d = %f * ug%d + %f * ug%d;\n", 
  283.             p, l_fact, l, r_fact, r);
  284.     else if(l)
  285.         sprintf(cmd, "ug%d = %f * ug%d;\n", p, l_fact, l);
  286.     else if(r)
  287.         sprintf(cmd, "ug%d = %f * ug%d;\n", p, r_fact, r);
  288.     else 
  289.         sprintf(cmd, "ug%d = 0.;\n", p);
  290.     inst.loop_list.append(cmd);
  291. }
  292.  
  293. void unit_generator::write_rand(int p, int l, int r)
  294. {
  295.     fprintf(fp, "\tfloat ug%d;\n",p);
  296.     declare(beg_int, beg_float, beg_float_ptr);
  297.     sprintf(cmd, "ug%d = rrand();\n", p);
  298.     inst.loop_list.append(cmd);
  299. }
  300.  
  301. void unit_generator::write_sub(int p, int l, int r)
  302. {
  303.     fprintf(fp, "\tfloat ug%d;\n",p);
  304.     declare(beg_int, beg_float, beg_float_ptr);
  305.     float l_fact, r_fact;
  306.     l_fact = atof(ugen[p].side->in0->value);
  307.     r_fact = atof(ugen[p].side->in1->value);
  308.     if(l && r)
  309.         sprintf(cmd, "ug%d = %f * ug%d - %f * ug%d;\n", 
  310.             p, l_fact, l, r_fact, r);
  311.     else if(l)
  312.         sprintf(cmd, "ug%d = %f * ug%d - %f;\n", p, l_fact, l, r_fact);
  313.     else if(r)
  314.         sprintf(cmd, "ug%d = %f - %f * ug%d;\n", p, l_fact, r_fact, r);
  315.     else 
  316.         sprintf(cmd, "ug%d = 0.;\n", p);
  317.     inst.loop_list.append(cmd);
  318. }
  319.  
  320. void unit_generator::write_mult(int p, int l, int r)
  321. {
  322.     fprintf(fp, "\tfloat ug%d;\n",p);
  323.     declare(beg_int, beg_float, beg_float_ptr);
  324.     float l_fact, r_fact;
  325.     l_fact = atof(ugen[p].side->in0->value);
  326.     r_fact = atof(ugen[p].side->in1->value);
  327.     if(l && r)
  328.         sprintf(cmd, "ug%d = %f * ug%d * %f * ug%d;\n", 
  329.             p, l_fact, l, r_fact, r);
  330.     else if(l)
  331.         sprintf(cmd, "ug%d = %f * ug%d * %f;\n", p, l_fact, l, r_fact);
  332.     else if(r)
  333.         sprintf(cmd, "ug%d = %f * %f * ug%d;\n", p, l_fact, r_fact, r);
  334.     else 
  335.         sprintf(cmd, "ug%d = 0.;\n", p);
  336.     inst.loop_list.append(cmd);
  337. }
  338.  
  339. void unit_generator::write_div(int p, int l, int r)
  340. {
  341.     fprintf(fp, "\tfloat ug%d;\n",p);
  342.     declare(beg_int, beg_float, beg_float_ptr);
  343.     float l_fact, r_fact;
  344.     l_fact = atof(ugen[p].side->in0->value);
  345.     r_fact = atof(ugen[p].side->in1->value);
  346.     if(l && r)
  347.         sprintf(cmd, "ug%d = (%f * ug%d) / (%f * ug%d);\n", 
  348.             p, l_fact, l, r_fact, r);
  349.     else if(l)
  350.         sprintf(cmd, "ug%d = (%f * ug%d) / %f;\n", p, l_fact, l, r_fact);
  351.     else if(r)
  352.         sprintf(cmd, "ug%d = %f / (%f * ug%d);\n", p, l_fact, r_fact, r);
  353.     else 
  354.         sprintf(cmd, "ug%d = 0.;\n", p);
  355.     inst.loop_list.append(cmd);
  356. }
  357.  
  358. void unit_generator::write_out(int p, int l, int r)
  359. {
  360.     sprintf(cmd, "out[0] = ug%d;\n",l);
  361.     inst.loop_list.append(cmd);
  362. // if mono
  363.     sprintf(cmd, "out[1] = out[0];\n");
  364.  
  365.     inst.loop_list.append(cmd);
  366. }
  367.  
  368. void unit_generator::declare(int in, int f, int p)
  369. {
  370.     for(int i = in; i < inst.num_ints; i++)
  371.         fprintf(fp,"\tint %s;\n",inst.ints[i]);
  372.     for(i = f; i < inst.num_sfloats; i++)
  373.         fprintf(fp,"\tfloat %s;\n",inst.sfloats[i]);
  374.     for(i = p; i < inst.num_float_ptrs; i++)
  375.         fprintf(fp,"\tfloat *%s;\n",inst.float_ptrs[i]);
  376. }
  377.  
  378. unit_generator::~unit_generator()
  379. {
  380.     fclose(fp);
  381. }
  382.  
  383. //*****************************************************
  384.  
  385. ugen_loc::ugen_loc(int type)
  386. {
  387.     if(type < 20) {
  388.         size = 75;
  389.         xoffset = yoffset = 37;
  390.     }
  391.     else {
  392.         size = 36;
  393.         xoffset = yoffset = 18;
  394.     }
  395. }
  396.     
  397. int ugen_loc::get_size()
  398. {
  399.     return size;
  400. }
  401.  
  402. int ugen_loc::get_xoffset()
  403. {
  404.     return xoffset;
  405. }
  406.  
  407. int ugen_loc::get_yoffset()
  408. {
  409.     return yoffset;
  410. }
  411.